Termination w.r.t. Q proof of /home/nowonder/forschung/aprove/satrung/aprove/lpar18/RubioSLASHenno.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

Q is empty.

↳ QTRS

  ↳ Non-Overlap Check

Q restricted rewrite system:
The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

Q is empty.

The TRS is non-overlapping. Hence, we can switch to innermost.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

F_3₃(pair₂(Y, Z), N, X) -> QSORT₁(Y)
F_3₃(pair₂(Y, Z), N, X) -> APPEND₂(qsort₁(Y), add₂(X, qsort₁(Z)))
F_1₄(pair₂(X, Z), N, M, Y) -> F_2₆(lt₂(N, M), N, M, Y, X, Z)
F_1₄(pair₂(X, Z), N, M, Y) -> LT₂(N, M)
QSORT₁(add₂(N, X)) -> F_3₃(split₂(N, X), N, X)
LT₂(s₁(X), s₁(Y)) -> LT₂(X, Y)
SPLIT₂(N, add₂(M, Y)) -> F_1₄(split₂(N, Y), N, M, Y)
APPEND₂(add₂(N, X), Y) -> APPEND₂(X, Y)
F_3₃(pair₂(Y, Z), N, X) -> QSORT₁(Z)
QSORT₁(add₂(N, X)) -> SPLIT₂(N, X)
SPLIT₂(N, add₂(M, Y)) -> SPLIT₂(N, Y)

The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

F_3₃(pair₂(Y, Z), N, X) -> QSORT₁(Y)
F_3₃(pair₂(Y, Z), N, X) -> APPEND₂(qsort₁(Y), add₂(X, qsort₁(Z)))
F_1₄(pair₂(X, Z), N, M, Y) -> F_2₆(lt₂(N, M), N, M, Y, X, Z)
F_1₄(pair₂(X, Z), N, M, Y) -> LT₂(N, M)
QSORT₁(add₂(N, X)) -> F_3₃(split₂(N, X), N, X)
LT₂(s₁(X), s₁(Y)) -> LT₂(X, Y)
SPLIT₂(N, add₂(M, Y)) -> F_1₄(split₂(N, Y), N, M, Y)
APPEND₂(add₂(N, X), Y) -> APPEND₂(X, Y)
F_3₃(pair₂(Y, Z), N, X) -> QSORT₁(Z)
QSORT₁(add₂(N, X)) -> SPLIT₂(N, X)
SPLIT₂(N, add₂(M, Y)) -> SPLIT₂(N, Y)

The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 4 SCCs with 5 less nodes.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APPEND₂(add₂(N, X), Y) -> APPEND₂(X, Y)

The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

APPEND₂(add₂(N, X), Y) -> APPEND₂(X, Y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
APPEND₂(x1, x2) = APPEND₁(x1)
add₂(x1, x2) = add₁(x2)

Lexicographic Path Order [19].
Precedence:

add₁ > APPEND₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LT₂(s₁(X), s₁(Y)) -> LT₂(X, Y)

The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

LT₂(s₁(X), s₁(Y)) -> LT₂(X, Y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
LT₂(x1, x2) = x2
s₁(x1) = s₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SPLIT₂(N, add₂(M, Y)) -> SPLIT₂(N, Y)

The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

SPLIT₂(N, add₂(M, Y)) -> SPLIT₂(N, Y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
SPLIT₂(x1, x2) = SPLIT₁(x2)
add₂(x1, x2) = add₁(x2)

Lexicographic Path Order [19].
Precedence:

add₁ > SPLIT₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

F_3₃(pair₂(Y, Z), N, X) -> QSORT₁(Y)
QSORT₁(add₂(N, X)) -> F_3₃(split₂(N, X), N, X)
F_3₃(pair₂(Y, Z), N, X) -> QSORT₁(Z)

The TRS R consists of the following rules:

lt₂(0, s₁(X)) -> true
lt₂(s₁(X), 0) -> false
lt₂(s₁(X), s₁(Y)) -> lt₂(X, Y)
append₂(nil, Y) -> Y
append₂(add₂(N, X), Y) -> add₂(N, append₂(X, Y))
split₂(N, nil) -> pair₂(nil, nil)
split₂(N, add₂(M, Y)) -> f_1₄(split₂(N, Y), N, M, Y)
f_1₄(pair₂(X, Z), N, M, Y) -> f_2₆(lt₂(N, M), N, M, Y, X, Z)
f_2₆(true, N, M, Y, X, Z) -> pair₂(X, add₂(M, Z))
f_2₆(false, N, M, Y, X, Z) -> pair₂(add₂(M, X), Z)
qsort₁(nil) -> nil
qsort₁(add₂(N, X)) -> f_3₃(split₂(N, X), N, X)
f_3₃(pair₂(Y, Z), N, X) -> append₂(qsort₁(Y), add₂(X, qsort₁(Z)))

The set Q consists of the following terms:

lt₂(0, s₁(x0))
lt₂(s₁(x0), 0)
lt₂(s₁(x0), s₁(x1))
append₂(nil, x0)
append₂(add₂(x0, x1), x2)
split₂(x0, nil)
split₂(x0, add₂(x1, x2))
f_1₄(pair₂(x0, x1), x2, x3, x4)
f_2₆(true, x0, x1, x2, x3, x4)
f_2₆(false, x0, x1, x2, x3, x4)
qsort₁(nil)
qsort₁(add₂(x0, x1))
f_3₃(pair₂(x0, x1), x2, x3)

We have to consider all minimal (P,Q,R)-chains.